{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FSRS4Anki Optimizer mini-batch_initial-stability_filter-data"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![open in colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-spaced-repetition/fsrs4anki/blob/main/archive/experiment/mini-batch_initial-stability.ipynb)\n",
    "\n",
    "↑ Click the above button to open the optimizer on Google Colab.\n",
    "\n",
    "> If you can't see the button and are located in the Chinese Mainland, please use a proxy or VPN."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Upload your **Anki Deck Package (.apkg)** file or **Anki Collection Package (.colpkg)** file on the `Left sidebar -> Files`, drag and drop your file in the current directory (not the `sample_data` directory). \n",
    "\n",
    "No need to include media. Need to include scheduling information. \n",
    "\n",
    "> If you use the latest version of Anki, please check the box `Support older Anki versions (slower/larger files)` when you export.\n",
    "\n",
    "You can export it via `File -> Export...` or `Ctrl + E` in the main window of Anki.\n",
    "\n",
    "Then replace the `filename` with yours in the next code cell. And set the `timezone` and `next_day_starts_at` which can be found in your preferences of Anki.\n",
    "\n",
    "After that, just run all (`Runtime -> Run all` or `Ctrl + F9`) and wait for minutes. You can see the optimal parameters in section **2.3 Result**. Copy them, replace the parameters in `fsrs4anki_scheduler.js`, and paste them into the custom scheduling of your deck options (require Anki version >= 2.1.55).\n",
    "\n",
    "**NOTE**: The default output is generated from my review logs. If you find the output is the same as mine, maybe your notebook hasn't run there.\n",
    "\n",
    "**Contribute to SRS Research**: If you want to share your data with me, please fill this form: https://forms.gle/KaojsBbhMCytaA7h8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here are some settings that you need to replace before running this optimizer.\n",
    "\n",
    "filename = \"./Main__English__Hard English_27.04.2023.apkg\"\n",
    "# If you upload deck file, replace it with your deck filename. E.g., ALL__Learning.apkg\n",
    "# If you upload collection file, replace it with your colpgk filename. E.g., collection-2022-09-18@13-21-58.colpkg\n",
    "\n",
    "# Replace it with your timezone. I'm in China, so I use Asia/Shanghai.\n",
    "# You can find your timezone here: https://gist.github.com/heyalexej/8bf688fd67d7199be4a1682b3eec7568\n",
    "timezone = 'Europe/Moscow'\n",
    "\n",
    "# Replace it with your Anki's setting in Preferences -> Scheduling.\n",
    "next_day_starts_at = 5\n",
    "\n",
    "# Replace it if you don't want the optimizer to use the review logs before a specific date.\n",
    "revlog_start_date = \"2006-10-05\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 Build dataset"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Extract Anki collection & deck file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extract successfully!\n"
     ]
    }
   ],
   "source": [
    "import zipfile\n",
    "import sqlite3\n",
    "import time\n",
    "from tqdm import notebook\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "from datetime import timedelta, datetime\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "import sys\n",
    "import torch\n",
    "from torch import nn\n",
    "from sklearn.utils import shuffle\n",
    "# Extract the collection file or deck file to get the .anki21 database.\n",
    "with zipfile.ZipFile(f'./{filename}', 'r') as zip_ref:\n",
    "    zip_ref.extractall('./')\n",
    "    print(\"Extract successfully!\")\n",
    "\n",
    "\n",
    "notebook.tqdm.pandas()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Create time-series feature & analysis\n",
    "\n",
    "The following code cell will extract the review logs from your Anki collection and preprocess them to a trainset which is saved in [./revlog_history.tsv](./revlog_history.tsv).\n",
    "\n",
    "The time-series features are important in optimizing the model's parameters. For more detail, please see my paper: https://www.maimemo.com/paper/\n",
    "\n",
    "Then it will generate a concise analysis for your review logs. \n",
    "\n",
    "- The `r_history` is the history of ratings on each review. `3,3,3,1` means that you press `Good, Good, Good, Again`. It only contains the first rating for each card on the review date, i.e., when you press `Again` in review and  `Good` in relearning steps 10min later, only `Again` will be recorded.\n",
    "- The `avg_interval` is the actual average interval after you rate your cards as the `r_history`. It could be longer than the interval given by Anki's built-in scheduler because you reviewed some overdue cards.\n",
    "- The `avg_retention` is the average retention after you press as the `r_history`. `Again` counts as failed recall, and `Hard, Good and Easy` count as successful recall. Retention is the percentage of your successful recall.\n",
    "- The `stability` is the estimated memory state variable, which is an approximate interval that leads to 90% retention.\n",
    "- The `factor` is `stability / previous stability`.\n",
    "- The `group_cnt` is the number of review logs that have the same `r_history`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "revlog.csv saved.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a2dea47004dc4ef9baa5007c016579e3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/6042 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "52619d43d998491fbf7e522f9b19e28c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/24011 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "63e72756c0fb45a3ad1dfac694608663",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5966 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trainset saved.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9890ae313bfc449e8f8583d5becda925",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5087 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Retention calculated.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "94d15f70af174adcb8a5ff3477a6ee73",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/2648 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stability calculated.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "16c1dd56fe604736820a2e50c45a94c9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/125 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1:again, 2:hard, 3:good, 4:easy\n",
      "\n",
      "r_history  avg_interval  avg_retention  stability  factor  group_cnt\n",
      "        2           1.1          0.580        0.2     inf       1390\n",
      "      2,3           1.1          0.960        2.9   14.50        422\n",
      "    2,3,3           3.9          0.988       32.9   11.34        180\n",
      "  2,3,3,3          23.9          0.803       10.0    0.30        142\n",
      "        3           1.1          0.837        0.7     inf       2830\n",
      "      3,3           5.0          0.961       14.1   20.14        681\n",
      "    3,3,3          30.5          0.921       34.1    2.42        328\n",
      "        4          11.9          0.980       77.2     inf       1360\n",
      "      4,3          38.5          0.984      230.7    2.99        405\n",
      "    4,3,3          42.4          0.984      285.4    1.24        112\n",
      "Analysis saved!\n"
     ]
    }
   ],
   "source": [
    "if os.path.isfile(\"collection.anki21b\"):\n",
    "    os.remove(\"collection.anki21b\")\n",
    "    raise Exception(\n",
    "        \"Please export the file with `support older Anki versions` if you use the latest version of Anki.\")\n",
    "elif os.path.isfile(\"collection.anki21\"):\n",
    "    con = sqlite3.connect(\"collection.anki21\")\n",
    "elif os.path.isfile(\"collection.anki2\"):\n",
    "    con = sqlite3.connect(\"collection.anki2\")\n",
    "else:\n",
    "    raise Exception(\"Collection not exist!\")\n",
    "cur = con.cursor()\n",
    "res = cur.execute(\"SELECT * FROM revlog\")\n",
    "revlog = res.fetchall()\n",
    "\n",
    "df = pd.DataFrame(revlog)\n",
    "df.columns = ['id', 'cid', 'usn', 'r', 'ivl',\n",
    "              'last_ivl', 'factor', 'time', 'type']\n",
    "df = df[(df['cid'] <= time.time() * 1000) &\n",
    "        (df['id'] <= time.time() * 1000) &\n",
    "        (df['r'] > 0)].copy()\n",
    "df['create_date'] = pd.to_datetime(df['cid'] // 1000, unit='s')\n",
    "df['create_date'] = df['create_date'].dt.tz_localize(\n",
    "    'UTC').dt.tz_convert(timezone)\n",
    "df['review_date'] = pd.to_datetime(df['id'] // 1000, unit='s')\n",
    "df['review_date'] = df['review_date'].dt.tz_localize(\n",
    "    'UTC').dt.tz_convert(timezone)\n",
    "df.drop(df[df['review_date'].dt.year < 2006].index, inplace=True)\n",
    "df.sort_values(by=['cid', 'id'], inplace=True, ignore_index=True)\n",
    "type_sequence = np.array(df['type'])\n",
    "time_sequence = np.array(df['time'])\n",
    "df.to_csv(\"revlog.csv\", index=False)\n",
    "print(\"revlog.csv saved.\")\n",
    "df = df[df['type'] != 3].copy()\n",
    "df['real_days'] = df['review_date'] - timedelta(hours=next_day_starts_at)\n",
    "df['real_days'] = pd.DatetimeIndex(df['real_days'].dt.floor('D', ambiguous='infer', nonexistent='shift_forward')).to_julian_date()\n",
    "\n",
    "# Remove `again` in `relearning` stage.\n",
    "df = df.drop(df[(df['type'] == 2) & (df['r'] == 1)].index)\n",
    "# Keep `easy` as the first rating when `easy` is in `learning` stage.\n",
    "cid_with_r_4 = df[(df['type'] == 0) & (df['r'] == 4)]['cid'].unique()\n",
    "df1 = df[(df['cid'].isin(cid_with_r_4)) & (df['type'] == 0) & (df['r'] == 4)]\n",
    "df2 = df[~((df['cid'].isin(cid_with_r_4)) & (df['type'] == 0) & (df['r'] != 4))]\n",
    "df = pd.concat([df1, df2])\n",
    "\n",
    "\n",
    "df.drop_duplicates(['cid', 'real_days'], keep='first', inplace=True)\n",
    "df.sort_values(by=['cid', 'id'], inplace=True, ignore_index=True)\n",
    "df['delta_t'] = df.real_days.diff()\n",
    "df.dropna(inplace=True)\n",
    "df['delta_t'] = df['delta_t'].astype(dtype=int)\n",
    "df['i'] = 1\n",
    "df['r_history'] = \"\"\n",
    "df['t_history'] = \"\"\n",
    "col_idx = {key: i for i, key in enumerate(df.columns)}\n",
    "\n",
    "\n",
    "# code from https://github.com/L-M-Sherlock/anki_revlog_analysis/blob/main/revlog_analysis.py\n",
    "def get_feature(x):\n",
    "    last_kind = None\n",
    "    for idx, log in enumerate(x.itertuples()):\n",
    "        if last_kind is not None and last_kind in (1, 2) and log.type == 0:\n",
    "            return x.iloc[:idx]\n",
    "        last_kind = log.type\n",
    "        if idx == 0:\n",
    "            if log.type != 0:\n",
    "                return x.iloc[:idx]\n",
    "            x.iloc[idx, col_idx['delta_t']] = 0\n",
    "        if idx == x.shape[0] - 1:\n",
    "            break\n",
    "        x.iloc[idx + 1, col_idx['i']] = x.iloc[idx, col_idx['i']] + 1\n",
    "        x.iloc[idx + 1, col_idx['t_history']] = f\"{x.iloc[idx, col_idx['t_history']]},{x.iloc[idx, col_idx['delta_t']]}\"\n",
    "        x.iloc[idx + 1, col_idx['r_history']] = f\"{x.iloc[idx, col_idx['r_history']]},{x.iloc[idx, col_idx['r']]}\"\n",
    "    return x\n",
    "\n",
    "df = df.groupby('cid', as_index=False, group_keys=False).progress_apply(get_feature)\n",
    "\n",
    "def remove_outliers(sub_df):\n",
    "    Q1 = sub_df['delta_t'].quantile(0.25)\n",
    "    Q3 = sub_df['delta_t'].quantile(0.75)\n",
    "    IQR = Q3 - Q1\n",
    "    return sub_df[(sub_df['delta_t'] >= Q1 - 1.5 * IQR) & (sub_df['delta_t'] <= Q3 + 1.5 * IQR)]\n",
    "\n",
    "df = df.groupby(['r_history', 't_history'], as_index=False, group_keys=False).progress_apply(remove_outliers)\n",
    "\n",
    "# Remove super-overdue reviews.\n",
    "df['last_ivl'] = df['last_ivl'].map(lambda x: 1 if x < 0 else x)\n",
    "df['overdue_rate'] = df['delta_t'] / df['last_ivl']\n",
    "df = df[df['overdue_rate'] < 4]\n",
    "del df['overdue_rate']\n",
    "\n",
    "def remove_non_continuous_rows(group):\n",
    "    discontinuity = group['i'].diff().fillna(1).ne(1)\n",
    "    if not discontinuity.any():\n",
    "        return group\n",
    "    else:\n",
    "        first_non_continuous_index = discontinuity.idxmax()\n",
    "        return group.loc[:first_non_continuous_index-1]\n",
    "\n",
    "df = df.groupby('cid', as_index=False, group_keys=False).progress_apply(remove_non_continuous_rows)\n",
    "\n",
    "df = df[df['id'] >= time.mktime(datetime.strptime(revlog_start_date, \"%Y-%m-%d\").timetuple()) * 1000]\n",
    "df[\"t_history\"] = df[\"t_history\"].map(lambda x: x[1:] if len(x) > 1 else x)\n",
    "df[\"r_history\"] = df[\"r_history\"].map(lambda x: x[1:] if len(x) > 1 else x)\n",
    "df.to_csv('revlog_history.tsv', sep=\"\\t\", index=False)\n",
    "print(\"Trainset saved.\")\n",
    "\n",
    "def cal_retention(group: pd.DataFrame) -> pd.DataFrame:\n",
    "    group['retention'] = round(group['r'].map(lambda x: {1: 0, 2: 1, 3: 1, 4: 1}[x]).mean(), 4)\n",
    "    group['total_cnt'] = group.shape[0]\n",
    "    return group\n",
    "\n",
    "df = df.groupby(by=['r_history', 'delta_t'], group_keys=False).progress_apply(cal_retention)\n",
    "print(\"Retention calculated.\")\n",
    "df = df.drop(columns=['id', 'cid', 'usn', 'ivl', 'last_ivl', 'factor', 'time', 'type', 'create_date', 'review_date', 'real_days', 'r', 't_history'])\n",
    "df.drop_duplicates(inplace=True)\n",
    "df['retention'] = df['retention'].map(lambda x: max(min(0.99, x), 0.01))\n",
    "\n",
    "def cal_stability(group: pd.DataFrame) -> pd.DataFrame:\n",
    "    group_cnt = sum(group['total_cnt'])\n",
    "    if group_cnt < 10:\n",
    "        return pd.DataFrame()\n",
    "    group['group_cnt'] = group_cnt\n",
    "    if group['i'].values[0] > 1:\n",
    "        r_ivl_cnt = sum(group['delta_t'] * group['retention'].map(np.log) * pow(group['total_cnt'], 2))\n",
    "        ivl_ivl_cnt = sum(group['delta_t'].map(lambda x: x ** 2) * pow(group['total_cnt'], 2))\n",
    "        group['stability'] = round(np.log(0.9) / (r_ivl_cnt / ivl_ivl_cnt), 1)\n",
    "    else:\n",
    "        group['stability'] = 0.0\n",
    "    group['avg_retention'] = round(sum(group['retention'] * pow(group['total_cnt'], 2)) / sum(pow(group['total_cnt'], 2)), 3)\n",
    "    group['avg_interval'] = round(sum(group['delta_t'] * pow(group['total_cnt'], 2)) / sum(pow(group['total_cnt'], 2)), 1)\n",
    "    del group['total_cnt']\n",
    "    del group['retention']\n",
    "    del group['delta_t']\n",
    "    return group\n",
    "\n",
    "df = df.groupby(by=['r_history'], group_keys=False).progress_apply(cal_stability)\n",
    "print(\"Stability calculated.\")\n",
    "df.reset_index(drop = True, inplace = True)\n",
    "df.drop_duplicates(inplace=True)\n",
    "df.sort_values(by=['r_history'], inplace=True, ignore_index=True)\n",
    "\n",
    "if df.shape[0] > 0:\n",
    "    for idx in notebook.tqdm(df.index):\n",
    "        item = df.loc[idx]\n",
    "        index = df[(df['i'] == item['i'] + 1) & (df['r_history'].str.startswith(item['r_history']))].index\n",
    "        df.loc[index, 'last_stability'] = item['stability']\n",
    "    df['factor'] = round(df['stability'] / df['last_stability'], 2)\n",
    "    df = df[(df['i'] >= 2) & (df['group_cnt'] >= 100)]\n",
    "    df['last_recall'] = df['r_history'].map(lambda x: x[-1])\n",
    "    df = df[df.groupby(['i', 'r_history'], group_keys=False)['group_cnt'].transform(max) == df['group_cnt']]\n",
    "    df.to_csv('./stability_for_analysis.tsv', sep='\\t', index=None)\n",
    "    print(\"1:again, 2:hard, 3:good, 4:easy\\n\")\n",
    "    print(df[df['r_history'].str.contains(r'^[1-4][^124]*$', regex=True)][['r_history', 'avg_interval', 'avg_retention', 'stability', 'factor', 'group_cnt']].to_string(index=False))\n",
    "    print(\"Analysis saved!\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Optimize parameter"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Define the model\n",
    "\n",
    "FSRS is a time-series model for predicting memory states."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "init_w = [0, 1, 5, 0.5, 0.5, 0.2, 1.4, 0.12, 0.8, 2, 0.2, 0.2, 1, 0, 0.5, 1, 2]\n",
    "'''\n",
    "w[0]: initial_stability_for_again_answer\n",
    "w[1]: initial_stability_step_per_rating\n",
    "w[2]: initial_difficulty_for_good_answer\n",
    "w[3]: initial_difficulty_step_per_rating\n",
    "w[4]: next_difficulty_step_per_rating\n",
    "w[5]: next_difficulty_reversion_to_mean_speed (used to avoid ease hell)\n",
    "w[6]: next_stability_factor_after_success\n",
    "w[7]: next_stability_stabilization_decay_after_success\n",
    "w[8]: next_stability_retrievability_gain_after_success\n",
    "w[9]: next_stability_factor_after_failure\n",
    "w[10]: next_stability_difficulty_decay_after_success\n",
    "w[11]: next_stability_stability_gain_after_failure\n",
    "w[12]: next_stability_retrievability_gain_after_failure\n",
    "For more details about the parameters, please see: \n",
    "https://github.com/open-spaced-repetition/fsrs4anki/wiki/Free-Spaced-Repetition-Scheduler\n",
    "'''\n",
    "\n",
    "\n",
    "class FSRS(nn.Module):\n",
    "    def __init__(self, w):\n",
    "        super(FSRS, self).__init__()\n",
    "        self.w = nn.Parameter(torch.tensor(w, dtype=torch.float32))\n",
    "\n",
    "    def stability_after_success(self, state, new_d, r):\n",
    "        new_s = state[:,0] * (1 + torch.exp(self.w[6]) *\n",
    "                        (11 - new_d) *\n",
    "                        torch.pow(state[:,0], -self.w[7]) *\n",
    "                        (torch.exp((1 - r) * self.w[8]) - 1))\n",
    "        return new_s\n",
    "    \n",
    "    def stability_after_failure(self, state, new_d, r):\n",
    "        new_s = self.w[9] * torch.pow(new_d, -self.w[10]) * torch.pow(\n",
    "            state[:,0], self.w[11]) * torch.exp((1 - r) * self.w[12])\n",
    "        return new_s\n",
    "\n",
    "    def step(self, X, state):\n",
    "        '''\n",
    "        :param X: shape[batch_size, 2], X[:,0] is elapsed time, X[:,1] is rating\n",
    "        :param state: shape[batch_size, 2], state[:,0] is stability, state[:,1] is difficulty\n",
    "        :return state:\n",
    "        '''\n",
    "        keys = torch.tensor([1, 2, 3, 4])\n",
    "        keys = keys.view(1, -1).expand(X[:,1].long().size(0), -1)\n",
    "        index = (X[:,1].long().unsqueeze(1) == keys).nonzero(as_tuple=True)\n",
    "        if torch.equal(state, torch.zeros_like(state)):\n",
    "            # first learn, init memory states\n",
    "            new_s = torch.exp(self.w[13+index[1]])\n",
    "            new_d = self.w[2] - self.w[3] * (X[:,1] - 3)\n",
    "            new_d = new_d.clamp(1, 10)\n",
    "        else:\n",
    "            r = torch.exp(np.log(0.9) * X[:,0] / state[:,0])\n",
    "            new_d = state[:,1] - self.w[4] * (X[:,1] - 3)\n",
    "            new_d = self.mean_reversion(self.w[2], new_d)\n",
    "            new_d = new_d.clamp(1, 10)\n",
    "            condition = X[:,1] > 1\n",
    "            new_s = torch.where(condition, self.stability_after_success(state, new_d, r), self.stability_after_failure(state, new_d, r))\n",
    "        return torch.stack([new_s, new_d], dim=1)\n",
    "\n",
    "    def forward(self, inputs, state=None):\n",
    "        '''\n",
    "        :param inputs: shape[seq_len, batch_size, 2]\n",
    "        '''\n",
    "        if state is None:\n",
    "            state = torch.zeros((inputs.shape[1], 2))\n",
    "        else:\n",
    "            state, = state\n",
    "        outputs = []\n",
    "        for X in inputs:\n",
    "            state = self.step(X, state)\n",
    "            outputs.append(state)\n",
    "        return torch.stack(outputs), state\n",
    "\n",
    "    def mean_reversion(self, init, current):\n",
    "        return self.w[5] * init + (1-self.w[5]) * current\n",
    "\n",
    "\n",
    "class WeightClipper(object):\n",
    "    def __init__(self, frequency=1):\n",
    "        self.frequency = frequency\n",
    "\n",
    "    def __call__(self, module):\n",
    "        if hasattr(module, 'w'):\n",
    "            w = module.w.data\n",
    "            w[2] = w[2].clamp(1, 10)\n",
    "            w[3] = w[3].clamp(0.1, 5)\n",
    "            w[4] = w[4].clamp(0.1, 5)\n",
    "            w[5] = w[5].clamp(0, 0.5)\n",
    "            w[6] = w[6].clamp(0, 2)\n",
    "            w[7] = w[7].clamp(0.01, 0.8)\n",
    "            w[8] = w[8].clamp(0.01, 1.5)\n",
    "            w[9] = w[9].clamp(0.5, 5)\n",
    "            w[10] = w[10].clamp(0.01, 2)\n",
    "            w[11] = w[11].clamp(0.01, 0.9)\n",
    "            w[12] = w[12].clamp(0.01, 4)\n",
    "            module.w.data = w\n",
    "\n",
    "def lineToTensor(line):\n",
    "    ivl = line[0].split(',')\n",
    "    response = line[1].split(',')\n",
    "    tensor = torch.zeros(len(response), 2)\n",
    "    for li, response in enumerate(response):\n",
    "        tensor[li][0] = int(ivl[li])\n",
    "        tensor[li][1] = int(response)\n",
    "    return tensor\n",
    "\n",
    "from torch.utils.data import Dataset, DataLoader, Sampler\n",
    "from torch.nn.utils.rnn import pad_sequence, pack_padded_sequence, pad_packed_sequence\n",
    "from typing import List\n",
    "\n",
    "class RevlogDataset(Dataset):\n",
    "    def __init__(self, dataframe):\n",
    "        padded = pad_sequence(dataframe['tensor'].to_list(), batch_first=True, padding_value=0)\n",
    "        self.x_train = padded.int()\n",
    "        self.t_train = torch.tensor(dataframe['delta_t'].values, dtype=torch.int)\n",
    "        self.y_train = torch.tensor(dataframe['y'].values, dtype=torch.float)\n",
    "        self.seq_len = torch.tensor(dataframe['tensor'].map(len).values, dtype=torch.long)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        return self.x_train[idx], self.t_train[idx], self.y_train[idx], self.seq_len[idx]\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.y_train)\n",
    "    \n",
    "class RevlogSampler(Sampler[List[int]]):\n",
    "    def __init__(self, data_source, batch_size):\n",
    "        self.data_source = data_source\n",
    "        self.batch_size = batch_size\n",
    "        lengths = np.array(data_source.seq_len)\n",
    "        indices = np.argsort(lengths)\n",
    "        full_batches, remainder = divmod(indices.size, self.batch_size)\n",
    "        if full_batches > 0:\n",
    "            self.batch_indices = np.split(indices[:-remainder], full_batches)\n",
    "        else:\n",
    "            self.batch_indices = []\n",
    "        if remainder:\n",
    "            self.batch_indices.append(indices[-remainder:])\n",
    "        self.batch_nums = len(self.batch_indices)\n",
    "        # seed = int(torch.empty((), dtype=torch.int64).random_().item())\n",
    "        seed = 2023\n",
    "        self.generator = torch.Generator()\n",
    "        self.generator.manual_seed(seed)\n",
    "\n",
    "    def __iter__(self):\n",
    "        yield from [self.batch_indices[idx] for idx in torch.randperm(self.batch_nums, generator=self.generator).tolist()]\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data_source)\n",
    "\n",
    "\n",
    "def collate_fn(batch):\n",
    "    sequences, delta_ts, labels, seq_lens = zip(*batch)\n",
    "    sequences_packed = pack_padded_sequence(torch.stack(sequences, dim=1), lengths=torch.stack(seq_lens), batch_first=False, enforce_sorted=False)\n",
    "    sequences_padded, length = pad_packed_sequence(sequences_packed, batch_first=False)\n",
    "    sequences_padded = torch.as_tensor(sequences_padded)\n",
    "    seq_lens = torch.as_tensor(length)\n",
    "    delta_ts = torch.as_tensor(delta_ts)\n",
    "    labels = torch.as_tensor(labels)\n",
    "    return sequences_padded, delta_ts, labels, seq_lens\n",
    "\n",
    "class Optimizer(object):\n",
    "    def __init__(self, train_set, test_set, n_epoch=1, lr=1e-2, batch_size=256) -> None:\n",
    "        self.model = FSRS(init_w)\n",
    "        self.optimizer = torch.optim.Adam(self.model.parameters(), lr=lr)\n",
    "        self.clipper = WeightClipper()\n",
    "        self.batch_size = batch_size\n",
    "        self.build_dataset(train_set, test_set)\n",
    "        self.n_epoch = n_epoch\n",
    "        self.batch_nums = self.next_train_data_loader.batch_sampler.batch_nums\n",
    "        self.scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(self.optimizer, T_max=self.batch_nums * n_epoch)\n",
    "        self.avg_train_losses = []\n",
    "        self.avg_eval_losses = []\n",
    "        self.loss_fn = nn.BCELoss(reduction='sum')\n",
    "\n",
    "    def build_dataset(self, train_set, test_set):\n",
    "        pre_train_set = train_set[train_set['i'] == 2]\n",
    "        self.pre_train_set = RevlogDataset(pre_train_set)\n",
    "        sampler = RevlogSampler(self.pre_train_set, batch_size=self.batch_size)\n",
    "        self.pre_train_data_loader = DataLoader(self.pre_train_set, batch_sampler=sampler, collate_fn=collate_fn)\n",
    "\n",
    "        next_train_set = train_set[train_set['i'] > 2]\n",
    "        self.next_train_set = RevlogDataset(next_train_set)\n",
    "        sampler = RevlogSampler(self.next_train_set, batch_size=self.batch_size)\n",
    "        self.next_train_data_loader = DataLoader(self.next_train_set, batch_sampler=sampler, collate_fn=collate_fn)\n",
    "\n",
    "        self.train_set = RevlogDataset(train_set)\n",
    "        sampler = RevlogSampler(self.train_set, batch_size=self.batch_size)\n",
    "        self.train_data_loader = DataLoader(self.train_set, batch_sampler=sampler, collate_fn=collate_fn)\n",
    "\n",
    "        self.test_set = RevlogDataset(test_set)\n",
    "        sampler = RevlogSampler(self.test_set, batch_size=self.batch_size)\n",
    "        self.test_data_loader = DataLoader(self.test_set, batch_sampler=sampler, collate_fn=collate_fn)\n",
    "        print(\"dataset built\")\n",
    "\n",
    "    def train(self):\n",
    "        # pretrain\n",
    "        self.eval()\n",
    "        pbar = notebook.tqdm(desc=\"pre-train\", colour=\"red\", total=len(self.pre_train_data_loader))\n",
    "\n",
    "        for k in range(self.n_epoch):\n",
    "            for i, batch in enumerate(self.pre_train_data_loader):\n",
    "                self.model.train()\n",
    "                self.optimizer.zero_grad()\n",
    "                sequences, delta_ts, labels, seq_lens = batch\n",
    "                real_batch_size = seq_lens.shape[0]\n",
    "                outputs, _ = self.model(sequences)\n",
    "                stabilities = outputs[seq_lens-1, torch.arange(real_batch_size), 0]\n",
    "                retentions = torch.exp(np.log(0.9) * delta_ts / stabilities)\n",
    "                loss = self.loss_fn(retentions, labels)\n",
    "                loss.backward()\n",
    "                self.optimizer.step()\n",
    "                self.model.apply(self.clipper)\n",
    "                pbar.update(n=real_batch_size)\n",
    "\n",
    "        pbar.close()\n",
    "        for name, param in self.model.named_parameters():\n",
    "            print(f\"{name}: {list(map(lambda x: round(float(x), 4),param))}\")\n",
    "\n",
    "        epoch_len = len(self.next_train_data_loader)\n",
    "        pbar = notebook.tqdm(desc=\"train\", colour=\"red\", total=epoch_len*self.n_epoch)\n",
    "        print_len = max(self.batch_nums*self.n_epoch // 10, 1)\n",
    "\n",
    "\n",
    "        for k in range(self.n_epoch):\n",
    "            self.eval()\n",
    "            for i, batch in enumerate(self.next_train_data_loader):\n",
    "                self.model.train()\n",
    "                self.optimizer.zero_grad()\n",
    "                sequences, delta_ts, labels, seq_lens = batch\n",
    "                real_batch_size = seq_lens.shape[0]\n",
    "                outputs, _ = self.model(sequences)\n",
    "                stabilities = outputs[seq_lens-1, torch.arange(real_batch_size), 0]\n",
    "                retentions = torch.exp(np.log(0.9) * delta_ts / stabilities)\n",
    "                loss = self.loss_fn(retentions, labels)\n",
    "                loss.backward()\n",
    "                for param in self.model.parameters():\n",
    "                    param.grad[:2] = torch.zeros(2)\n",
    "                    param.grad[13:17] = torch.zeros(4)\n",
    "                self.optimizer.step()\n",
    "                self.scheduler.step()\n",
    "                self.model.apply(self.clipper)\n",
    "                pbar.update(real_batch_size)\n",
    "\n",
    "                if (k * self.batch_nums + i + 1) % print_len == 0:\n",
    "                    print(f\"iteration: {k * epoch_len + (i + 1) * self.batch_size}\")\n",
    "                    for name, param in self.model.named_parameters():\n",
    "                        print(f\"{name}: {list(map(lambda x: round(float(x), 4),param))}\")\n",
    "        pbar.close()\n",
    "                \n",
    "        self.eval()\n",
    "\n",
    "        w = list(map(lambda x: round(float(x), 4), dict(self.model.named_parameters())['w'].data))\n",
    "        return w\n",
    "\n",
    "    def eval(self):\n",
    "        self.model.eval()\n",
    "        with torch.no_grad():\n",
    "            sampler = RevlogSampler(self.train_set, batch_size=4096)\n",
    "            train_data_loader = DataLoader(self.train_set, batch_sampler=sampler, collate_fn=collate_fn)\n",
    "            loss = 0\n",
    "            for batch in train_data_loader:\n",
    "                sequences, delta_ts, labels, seq_lens = batch\n",
    "                real_batch_size = seq_lens.shape[0]\n",
    "                outputs, _ = self.model(sequences)\n",
    "                stabilities = outputs[seq_lens-1, torch.arange(real_batch_size), 0]\n",
    "                retentions = torch.exp(np.log(0.9) * delta_ts / stabilities)\n",
    "                loss += self.loss_fn(retentions, labels)\n",
    "            self.avg_train_losses.append(loss/len(train_data_loader))\n",
    "            print(f\"Loss in trainset: {self.avg_train_losses[-1]:.4f}\")\n",
    "\n",
    "            sampler = RevlogSampler(self.test_set, batch_size=4096)\n",
    "            test_data_loader = DataLoader(self.test_set, batch_sampler=sampler, collate_fn=collate_fn)\n",
    "            loss = 0\n",
    "            for batch in test_data_loader:\n",
    "                sequences, delta_ts, labels, seq_lens = batch\n",
    "                real_batch_size = seq_lens.shape[0]\n",
    "                outputs, _ = self.model(sequences)\n",
    "                stabilities = outputs[seq_lens-1, torch.arange(real_batch_size), 0]\n",
    "                retentions = torch.exp(np.log(0.9) * delta_ts / stabilities)\n",
    "                loss += self.loss_fn(retentions, labels)\n",
    "            self.avg_eval_losses.append(loss/len(test_data_loader))\n",
    "            print(f\"Loss in testset: {self.avg_eval_losses[-1]:.4f}\")\n",
    "\n",
    "    def plot(self):\n",
    "        plt.plot(self.avg_train_losses, label='train')\n",
    "        plt.plot(self.avg_eval_losses, label='test')\n",
    "        plt.xlabel('epoch')\n",
    "        plt.ylabel('loss')\n",
    "        plt.legend()\n",
    "        plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Train the model\n",
    "\n",
    "The [./revlog_history.tsv](./revlog_history.tsv) generated before will be used for training the FSRS model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cbf5cd80dfa348509c36f67651e6274b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/16857 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensorized!\n",
      "dataset built\n",
      "Loss in trainset: 0.4052\n",
      "Loss in testset: 0.4052\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "75982aa59ae448d1a85302cd9796c9e4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "pre-train:   0%|          | 0/5583 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w: [0.0, 1.0, 5.0, 0.5, 0.5, 0.2, 1.4, 0.12, 0.8, 2.0, 0.2, 0.2, 1.0, 0.6968, -1.2052, -0.3282, 3.4795]\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "03c2cbd7af4a43be983e3e3847c6bc1a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "train:   0%|          | 0/56370 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss in trainset: 0.3391\n",
      "Loss in testset: 0.3391\n",
      "iteration: 5632\n",
      "w: [0.0, 1.0, 5.0064, 0.9808, 0.9602, 0.0, 1.5257, 0.011, 0.9273, 1.7551, 0.4481, 0.613, 0.7144, 0.7711, -1.347, -0.3892, 3.5745]\n",
      "iteration: 11264\n",
      "w: [0.0, 1.0, 4.948, 1.3406, 1.3264, 0.0, 1.7215, 0.0288, 1.1175, 1.864, 0.3474, 0.7506, 0.8726, 0.7955, -1.3936, -0.4092, 3.6058]\n",
      "Loss in trainset: 0.3188\n",
      "Loss in testset: 0.3188\n",
      "iteration: 16394\n",
      "w: [0.0, 1.0, 5.0069, 1.5606, 1.5516, 0.0, 1.6591, 0.099, 1.0724, 1.8575, 0.365, 0.6489, 0.9808, 0.8031, -1.4081, -0.4155, 3.6154]\n",
      "iteration: 22026\n",
      "w: [0.0, 1.0, 4.881, 1.5352, 1.5707, 0.0, 1.7481, 0.01, 1.15, 1.8857, 0.3397, 0.6436, 1.1146, 0.8053, -1.4123, -0.4173, 3.6183]\n",
      "Loss in trainset: 0.3186\n",
      "Loss in testset: 0.3186\n",
      "iteration: 27156\n",
      "w: [0.0, 1.0, 4.8124, 1.4702, 1.6135, 0.0, 1.7722, 0.0116, 1.1664, 1.8194, 0.4111, 0.6749, 1.1185, 0.8059, -1.4134, -0.4178, 3.619]\n",
      "iteration: 32788\n",
      "w: [0.0, 1.0, 4.8285, 1.4623, 1.6824, 0.0, 1.7348, 0.0597, 1.1301, 1.8558, 0.3754, 0.6735, 1.2001, 0.806, -1.4137, -0.4179, 3.6192]\n",
      "Loss in trainset: 0.3183\n",
      "Loss in testset: 0.3183\n",
      "iteration: 37918\n",
      "w: [0.0, 1.0, 4.8229, 1.4643, 1.6774, 0.0, 1.7055, 0.0616, 1.1002, 1.8744, 0.3578, 0.7069, 1.242, 0.8061, -1.4138, -0.4179, 3.6193]\n",
      "iteration: 43550\n",
      "w: [0.0, 1.0, 4.8003, 1.4532, 1.6572, 0.0, 1.6953, 0.0508, 1.0884, 1.8692, 0.3636, 0.7052, 1.2525, 0.8061, -1.4138, -0.4179, 3.6193]\n",
      "Loss in trainset: 0.3182\n",
      "Loss in testset: 0.3182\n",
      "iteration: 48680\n",
      "w: [0.0, 1.0, 4.7836, 1.4485, 1.653, 0.0, 1.707, 0.0332, 1.0984, 1.8685, 0.365, 0.7029, 1.2641, 0.8061, -1.4138, -0.4179, 3.6193]\n",
      "iteration: 54312\n",
      "w: [0.0, 1.0, 4.7797, 1.4473, 1.6525, 0.0, 1.7102, 0.0287, 1.1012, 1.8679, 0.3656, 0.7025, 1.2662, 0.8061, -1.4138, -0.4179, 3.6193]\n",
      "Loss in trainset: 0.3182\n",
      "Loss in testset: 0.3182\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Training finished!\n"
     ]
    }
   ],
   "source": [
    "dataset = pd.read_csv(\"./revlog_history.tsv\", sep='\\t', index_col=None, dtype={'r_history': str ,'t_history': str} )\n",
    "dataset = dataset[(dataset['i'] > 1) & (dataset['delta_t'] > 0) & (dataset['t_history'].str.count(',0') == 0)]\n",
    "dataset['tensor'] = dataset.progress_apply(lambda x: lineToTensor(list(zip([x['t_history']], [x['r_history']]))[0]), axis=1)\n",
    "dataset['y'] = dataset['r'].map({1: 0, 2: 1, 3: 1, 4: 1})\n",
    "dataset['group'] = dataset['r_history'] + dataset['t_history']\n",
    "print(\"Tensorized!\")\n",
    "\n",
    "from sklearn.model_selection import StratifiedGroupKFold\n",
    "\n",
    "w = []\n",
    "\n",
    "# sgkf = StratifiedGroupKFold(n_splits=5)\n",
    "# for train_index, test_index in sgkf.split(dataset, dataset['i'], dataset['group']):\n",
    "#     print(\"TRAIN:\", len(train_index), \"TEST:\",  len(test_index))\n",
    "#     train_set = dataset.iloc[train_index].copy()\n",
    "#     test_set = dataset.iloc[test_index].copy()\n",
    "#     optimizer = Optimizer(train_set, test_set, n_epoch=5, lr=4e-2, batch_size=512)\n",
    "#     w.append(optimizer.train())\n",
    "#     optimizer.plot()\n",
    "\n",
    "optimizer = Optimizer(dataset, dataset, n_epoch=5, lr=4e-2, batch_size=512)\n",
    "w.append(optimizer.train())\n",
    "optimizer.plot()\n",
    "\n",
    "print(\"\\nTraining finished!\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Result\n",
    "\n",
    "Copy the optimal parameters for FSRS for you in the output of next code cell after running."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0, 1.0, 4.7796, 1.4473, 1.6526, 0.0, 1.7102, 0.0286, 1.1012, 1.8678, 0.3658, 0.7024, 1.2662, 0.8061, -1.4138, -0.4179, 3.6193]\n"
     ]
    }
   ],
   "source": [
    "w = np.array(w)\n",
    "avg_w = np.round(np.mean(w, axis=0), 4)\n",
    "print(avg_w.tolist())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4 Preview\n",
    "\n",
    "You can see the memory states and intervals generated by FSRS as if you press the good in each review at the due date scheduled by FSRS."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1:again, 2:hard, 3:good, 4:easy\n",
      "\n",
      "first rating: 1\n",
      "rating history: 1,3,3,3,3,3,3,3,3,3,3\n",
      "interval history: 0,2,6,19,56,163,465,1300,3567,9611,25441\n",
      "difficulty history: 0,7.7,7.7,7.7,7.7,7.7,7.7,7.7,7.7,7.7,7.7\n",
      "\n",
      "first rating: 2\n",
      "rating history: 2,3,3,3,3,3,3,3,3,3,3\n",
      "interval history: 0,1,3,12,47,176,642,2282,7903,26689,87962\n",
      "difficulty history: 0,6.2,6.2,6.2,6.2,6.2,6.2,6.2,6.2,6.2,6.2\n",
      "\n",
      "first rating: 3\n",
      "rating history: 3,3,3,3,3,3,3,3,3,3,3\n",
      "interval history: 0,1,5,24,112,504,2193,9240,37737,149531,575405\n",
      "difficulty history: 0,4.8,4.8,4.8,4.8,4.8,4.8,4.8,4.8,4.8,4.8\n",
      "\n",
      "first rating: 4\n",
      "rating history: 4,3,3,3,3,3,3,3,3,3,3\n",
      "interval history: 0,37,202,1059,5342,25971,121829,552050,2419081,10261885,42184576\n",
      "difficulty history: 0,3.3,3.3,3.3,3.3,3.3,3.3,3.3,3.3,3.3,3.3\n",
      "\n"
     ]
    }
   ],
   "source": [
    "requestRetention = 0.9  # recommended setting: 0.8 ~ 0.9\n",
    "\n",
    "\n",
    "class Collection:\n",
    "    def __init__(self, w):\n",
    "        self.model = FSRS(w)\n",
    "        self.model.eval()\n",
    "\n",
    "    def predict(self, t_history, r_history):\n",
    "        with torch.no_grad():\n",
    "            line_tensor = lineToTensor(list(zip([t_history], [r_history]))[0]).unsqueeze(1)\n",
    "            output_t = self.model(line_tensor)\n",
    "            return output_t[-1][0]\n",
    "        \n",
    "    def batch_predict(self, dataset):\n",
    "        fast_dataset = RevlogDataset(dataset)\n",
    "        outputs, _ = self.model(fast_dataset.x_train.transpose(0, 1))\n",
    "        stabilities, difficulties = outputs[fast_dataset.seq_len-1, torch.arange(len(fast_dataset))].transpose(0, 1)\n",
    "        return stabilities.tolist(), difficulties.tolist()\n",
    "\n",
    "my_collection = Collection(avg_w)\n",
    "print(\"1:again, 2:hard, 3:good, 4:easy\\n\")\n",
    "for first_rating in (1,2,3,4):\n",
    "    print(f'first rating: {first_rating}')\n",
    "    t_history = \"0\"\n",
    "    d_history = \"0\"\n",
    "    r_history = f\"{first_rating}\"  # the first rating of the new card\n",
    "    # print(\"stability, difficulty, lapses\")\n",
    "    for i in range(10):\n",
    "        states = my_collection.predict(t_history, r_history)\n",
    "        # print('{0:9.2f} {1:11.2f} {2:7.0f}'.format(\n",
    "            # *list(map(lambda x: round(float(x), 4), states))))\n",
    "        next_t = max(round(float(np.log(requestRetention)/np.log(0.9) * states[0])), 1)\n",
    "        difficulty = round(float(states[1]), 1)\n",
    "        t_history += f',{int(next_t)}'\n",
    "        d_history += f',{difficulty}'\n",
    "        r_history += f\",3\"\n",
    "    print(f\"rating history: {r_history}\")\n",
    "    print(f\"interval history: {t_history}\")\n",
    "    print(f\"difficulty history: {d_history}\")\n",
    "    print('')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can change the `test_rating_sequence` to see the scheduling intervals in different ratings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0.6584, 4.7796])\n",
      "tensor([4.7120, 4.7796])\n",
      "tensor([23.8677,  4.7796])\n",
      "tensor([111.6396,   4.7796])\n",
      "tensor([503.5611,   4.7796])\n",
      "tensor([78.0301,  8.0848])\n",
      "tensor([19.4816, 10.0000])\n",
      "tensor([30.7169, 10.0000])\n",
      "tensor([48.8118, 10.0000])\n",
      "tensor([77.0369, 10.0000])\n",
      "tensor([120.8152,  10.0000])\n",
      "tensor([188.7302,  10.0000])\n",
      "rating history: 3,3,3,3,3,1,1,3,3,3,3,3\n",
      "interval history: 0,1,5,24,112,504,78,19,31,49,77,121,189\n",
      "difficulty history: 0,4.8,4.8,4.8,4.8,4.8,8.1,10.0,10.0,10.0,10.0,10.0,10.0\n"
     ]
    }
   ],
   "source": [
    "test_rating_sequence = \"3,3,3,3,3,1,1,3,3,3,3,3\"\n",
    "requestRetention = 0.9  # recommended setting: 0.8 ~ 0.9\n",
    "easyBonus = 1.3\n",
    "hardInterval = 1.2\n",
    "\n",
    "t_history = \"0\"\n",
    "d_history = \"0\"\n",
    "for i in range(len(test_rating_sequence.split(','))):\n",
    "    rating = test_rating_sequence[2*i]\n",
    "    last_t = int(t_history.split(',')[-1])\n",
    "    r_history = test_rating_sequence[:2*i+1]\n",
    "    states = my_collection.predict(t_history, r_history)\n",
    "    print(states)\n",
    "    next_t = max(1,round(float(np.log(requestRetention)/np.log(0.9) * states[0])))\n",
    "    if rating == '4':\n",
    "        next_t = round(next_t * easyBonus)\n",
    "    elif rating == '2':\n",
    "        next_t = round(last_t * hardInterval)\n",
    "    t_history += f',{int(next_t)}'\n",
    "    difficulty = round(float(states[1]), 1)\n",
    "    d_history += f',{difficulty}'\n",
    "print(f\"rating history: {test_rating_sequence}\")\n",
    "print(f\"interval history: {t_history}\")\n",
    "print(f\"difficulty history: {d_history}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5 Predict memory states and distribution of difficulty\n",
    "\n",
    "Predict memory states for each review group and save them in [./prediction.tsv](./prediction.tsv).\n",
    "\n",
    "Meanwhile, it will count the distribution of difficulty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "prediction.tsv saved.\n",
      "difficulty\n",
      "1     0.003144\n",
      "2     0.020170\n",
      "3     0.121077\n",
      "5     0.253841\n",
      "6     0.168654\n",
      "7     0.015305\n",
      "8     0.111408\n",
      "9     0.000119\n",
      "10    0.306282\n",
      "Name: count, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "stabilities, difficulties = my_collection.batch_predict(dataset)\n",
    "stabilities = map(lambda x: round(x, 2), stabilities)\n",
    "difficulties = map(lambda x: round(x, 2), difficulties)\n",
    "dataset['stability'] = list(stabilities)\n",
    "dataset['difficulty'] = list(difficulties)\n",
    "prediction = dataset.groupby(by=['t_history', 'r_history']).agg({\"stability\": \"mean\", \"difficulty\": \"mean\", \"id\": \"count\"})\n",
    "prediction.reset_index(inplace=True)\n",
    "prediction.sort_values(by=['r_history'], inplace=True)\n",
    "prediction.rename(columns={\"id\": \"count\"}, inplace=True)\n",
    "prediction.to_csv(\"./prediction.tsv\", sep='\\t', index=None)\n",
    "print(\"prediction.tsv saved.\")\n",
    "prediction['difficulty'] = prediction['difficulty'].map(lambda x: int(round(x)))\n",
    "difficulty_distribution = prediction.groupby(by=['difficulty'])['count'].sum() / prediction['count'].sum()\n",
    "print(difficulty_distribution)\n",
    "difficulty_distribution_padding = np.zeros(10)\n",
    "for i in range(10):\n",
    "    if i+1 in difficulty_distribution.index:\n",
    "        difficulty_distribution_padding[i] = difficulty_distribution.loc[i+1]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Optimize retention to minimize the time of reviews\n",
    "\n",
    "Calculate the optimal retention to minimize the time for long-term memory consolidation. It is an experimental feature. You can use the simulator to get more accurate results:\n",
    "\n",
    "https://github.com/open-spaced-repetition/fsrs4anki/blob/main/fsrs4anki_simulator.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "average time for failed cards: 22.6s\n",
      "average time for recalled cards: 5.2s\n",
      "terminal stability:  100.18\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b300a34c6267496c93c929f1d7a29fe3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/15 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "expected_time.csv saved.\n",
      "\n",
      "-----suggested retention (experimental): 0.84-----\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "base = 1.01\n",
    "index_len = 664\n",
    "index_offset = 200\n",
    "d_range = 10\n",
    "d_offset = 1\n",
    "r_time = 8\n",
    "f_time = 25\n",
    "max_time = 200000\n",
    "\n",
    "type_block = dict()\n",
    "type_count = dict()\n",
    "type_time = dict()\n",
    "last_t = type_sequence[0]\n",
    "type_block[last_t] = 1\n",
    "type_count[last_t] = 1\n",
    "type_time[last_t] = time_sequence[0]\n",
    "for i,t in enumerate(type_sequence[1:]):\n",
    "    type_count[t] = type_count.setdefault(t, 0) + 1\n",
    "    type_time[t] = type_time.setdefault(t, 0) + time_sequence[i]\n",
    "    if t != last_t:\n",
    "        type_block[t] = type_block.setdefault(t, 0) + 1\n",
    "    last_t = t\n",
    "\n",
    "r_time = round(type_time[1]/type_count[1]/1000, 1)\n",
    "\n",
    "if 2 in type_count and 2 in type_block:\n",
    "    f_time = round(type_time[2]/type_block[2]/1000 + r_time, 1)\n",
    "\n",
    "print(f\"average time for failed cards: {f_time}s\")\n",
    "print(f\"average time for recalled cards: {r_time}s\")\n",
    "\n",
    "def stability2index(stability):\n",
    "    return int(round(np.log(stability) / np.log(base)) + index_offset)\n",
    "\n",
    "def init_stability(d):\n",
    "    return max(avg_w[12+int((d - avg_w[2]) / -avg_w[3] + 2)] * avg_w[1] + avg_w[0], np.power(base, -index_offset))\n",
    "\n",
    "def cal_next_recall_stability(s, r, d, response):\n",
    "    if response == 1:\n",
    "        return s * (1 + np.exp(avg_w[6]) * (11 - d) * np.power(s, -avg_w[7]) * (np.exp((1 - r) * avg_w[8]) - 1))\n",
    "    else:\n",
    "        return avg_w[9] * np.power(d, -avg_w[10]) * np.power(s, avg_w[11]) * np.exp((1 - r) * avg_w[12])\n",
    "\n",
    "\n",
    "stability_list = np.array([np.power(base, i - index_offset) for i in range(index_len)])\n",
    "print(f\"terminal stability: {stability_list.max(): .2f}\")\n",
    "df = pd.DataFrame(columns=[\"retention\", \"difficulty\", \"time\"])\n",
    "\n",
    "for percentage in notebook.tqdm(range(96, 66, -2)):\n",
    "    recall = percentage / 100\n",
    "    time_list = np.zeros((d_range, index_len))\n",
    "    time_list[:,:-1] = max_time\n",
    "    for d in range(d_range, 0, -1):\n",
    "        s0 = init_stability(d)\n",
    "        s0_index = stability2index(s0)\n",
    "        diff = max_time\n",
    "        while diff > 0.1:\n",
    "            s0_time = time_list[d - 1][s0_index]\n",
    "            for s_index in range(index_len - 2, -1, -1):\n",
    "                stability = stability_list[s_index]\n",
    "                interval = max(1, round(stability * np.log(recall) / np.log(0.9)))\n",
    "                p_recall = np.power(0.9, interval / stability)\n",
    "                recall_s = cal_next_recall_stability(stability, p_recall, d, 1)\n",
    "                forget_d = min(d + d_offset, 10)\n",
    "                forget_s = cal_next_recall_stability(stability, p_recall, forget_d, 0)\n",
    "                recall_s_index = min(stability2index(recall_s), index_len - 1)\n",
    "                forget_s_index = min(max(stability2index(forget_s), 0), index_len - 1)\n",
    "                recall_time = time_list[d - 1][recall_s_index] + r_time\n",
    "                forget_time = time_list[forget_d - 1][forget_s_index] + f_time\n",
    "                exp_time = p_recall * recall_time + (1.0 - p_recall) * forget_time\n",
    "                if exp_time < time_list[d - 1][s_index]:\n",
    "                    time_list[d - 1][s_index] = exp_time\n",
    "            diff = s0_time - time_list[d - 1][s0_index]\n",
    "        df.loc[0 if pd.isnull(df.index.max()) else df.index.max() + 1] = [recall, d, s0_time]\n",
    "\n",
    "df.sort_values(by=[\"difficulty\", \"retention\"], inplace=True)\n",
    "df.to_csv(\"./expected_time.csv\", index=False)\n",
    "print(\"expected_time.csv saved.\")\n",
    "\n",
    "optimal_retention_list = np.zeros(10)\n",
    "for d in range(1, d_range+1):\n",
    "    retention = df[df[\"difficulty\"] == d][\"retention\"]\n",
    "    time = df[df[\"difficulty\"] == d][\"time\"]\n",
    "    optimal_retention = retention.iat[time.argmin()]\n",
    "    optimal_retention_list[d-1] = optimal_retention\n",
    "    plt.plot(retention, time, label=f\"d={d}, r={optimal_retention}\")\n",
    "print(f\"\\n-----suggested retention (experimental): {np.inner(difficulty_distribution_padding, optimal_retention_list):.2f}-----\")\n",
    "plt.ylabel(\"expected time (second)\")\n",
    "plt.xlabel(\"retention\")\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "plt.semilogy()\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 Evaluate the model"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 Loss\n",
    "\n",
    "Evaluate the model with the log loss. It will compare the log loss between initial model and trained model.\n",
    "\n",
    "And it will predict the stability, difficulty and retrievability for each revlog in [./evaluation.tsv](./evaluation.tsv)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss before training: 0.4052\n",
      "Loss after training: 0.3182\n"
     ]
    }
   ],
   "source": [
    "my_collection = Collection(init_w)\n",
    "stabilities, difficulties = my_collection.batch_predict(dataset)\n",
    "dataset['stability'] = stabilities\n",
    "dataset['difficulty'] = difficulties\n",
    "dataset['p'] = np.exp(np.log(0.9) * dataset['delta_t'] / dataset['stability'])\n",
    "dataset['log_loss'] = dataset.apply(lambda row: - np.log(row['p']) if row['y'] == 1 else - np.log(1 - row['p']), axis=1)\n",
    "print(f\"Loss before training: {dataset['log_loss'].mean():.4f}\")\n",
    "\n",
    "my_collection = Collection(avg_w)\n",
    "stabilities, difficulties = my_collection.batch_predict(dataset)\n",
    "dataset['stability'] = stabilities\n",
    "dataset['difficulty'] = difficulties\n",
    "dataset['p'] = np.exp(np.log(0.9) * dataset['delta_t'] / dataset['stability'])\n",
    "dataset['log_loss'] = dataset.apply(lambda row: - np.log(row['p']) if row['y'] == 1 else - np.log(1 - row['p']), axis=1)\n",
    "print(f\"Loss after training: {dataset['log_loss'].mean():.4f}\")\n",
    "\n",
    "tmp = dataset.copy()\n",
    "tmp['stability'] = tmp['stability'].map(lambda x: round(x, 2))\n",
    "tmp['difficulty'] = tmp['difficulty'].map(lambda x: round(x, 2))\n",
    "tmp['p'] = tmp['p'].map(lambda x: round(x, 2))\n",
    "tmp['log_loss'] = tmp['log_loss'].map(lambda x: round(x, 2))\n",
    "tmp.rename(columns={\"r\": \"grade\", \"p\": \"retrievability\"}, inplace=True)\n",
    "tmp[['id', 'cid', 'review_date', 'r_history', 't_history', 'delta_t', 'grade', 'stability', 'difficulty', 'retrievability', 'log_loss']].to_csv(\"./evaluation.tsv\", sep='\\t', index=False)\n",
    "del tmp"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 Calibration graph\n",
    "\n",
    "1. FSRS predicts the stability and retention for each review.\n",
    "2. Reviews are grouped into 40 bins according to their predicted retention.\n",
    "3. Count the true retention of each bin.\n",
    "4. Plot (predicted retention, true retention) in the line graph.\n",
    "5. Plot (predicted retention, size of bin) in the bar graph.\n",
    "6. Combine these graphs to create the calibration graph.\n",
    "\n",
    "Ideally, the blue line should be aligned with the orange one. If the blue line is higher than the orange line, the FSRS underestimates the retention. When the size of reviews within a bin is small, actual retention may deviate largely, which is normal.\n",
    "\n",
    "R-squared (aka the coefficient of determination), is the proportion of the variation in the dependent variable that is predictable from the independent variable(s). The higher the R-squared, the better the model fits your data. For details, please see https://en.wikipedia.org/wiki/Coefficient_of_determination\n",
    "\n",
    "RMSE (root mean squared error) is the square root of the average of squared differences between prediction and actual observation. The lower the RMSE, the better the model fits your data. For details, please see https://en.wikipedia.org/wiki/Root-mean-square_deviation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R-squared: 0.9114\n",
      "RMSE: 0.0372\n",
      "[0.03810872 0.95965497]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import mean_squared_error, r2_score\n",
    "import statsmodels.api as sm\n",
    "\n",
    "\n",
    "# code from https://github.com/papousek/duolingo-halflife-regression/blob/master/evaluation.py\n",
    "def load_brier(predictions, real, bins=20):\n",
    "    counts = np.zeros(bins)\n",
    "    correct = np.zeros(bins)\n",
    "    prediction = np.zeros(bins)\n",
    "    for p, r in zip(predictions, real):\n",
    "        bin = min(int(p * bins), bins - 1)\n",
    "        counts[bin] += 1\n",
    "        correct[bin] += r\n",
    "        prediction[bin] += p\n",
    "    np.seterr(invalid='ignore')\n",
    "    prediction_means = prediction / counts\n",
    "    prediction_means[np.isnan(prediction_means)] = ((np.arange(bins) + 0.5) / bins)[np.isnan(prediction_means)]\n",
    "    correct_means = correct / counts\n",
    "    correct_means[np.isnan(correct_means)] = 0\n",
    "    size = len(predictions)\n",
    "    answer_mean = sum(correct) / size\n",
    "    return {\n",
    "        \"reliability\": sum(counts * (correct_means - prediction_means) ** 2) / size,\n",
    "        \"resolution\": sum(counts * (correct_means - answer_mean) ** 2) / size,\n",
    "        \"uncertainty\": answer_mean * (1 - answer_mean),\n",
    "        \"detail\": {\n",
    "            \"bin_count\": bins,\n",
    "            \"bin_counts\": list(counts),\n",
    "            \"bin_prediction_means\": list(prediction_means),\n",
    "            \"bin_correct_means\": list(correct_means),\n",
    "        }\n",
    "    }\n",
    "\n",
    "\n",
    "def plot_brier(predictions, real, bins=20):\n",
    "    brier = load_brier(predictions, real, bins=bins)\n",
    "    bin_prediction_means = brier['detail']['bin_prediction_means']\n",
    "    bin_correct_means = brier['detail']['bin_correct_means']\n",
    "    bin_counts = brier['detail']['bin_counts']\n",
    "    r2 = r2_score(bin_correct_means, bin_prediction_means, sample_weight=bin_counts)\n",
    "    rmse = np.sqrt(mean_squared_error(bin_correct_means, bin_prediction_means, sample_weight=bin_counts))\n",
    "    print(f\"R-squared: {r2:.4f}\")\n",
    "    print(f\"RMSE: {rmse:.4f}\")\n",
    "    plt.figure()\n",
    "    ax = plt.gca()\n",
    "    ax.set_xlim([0, 1])\n",
    "    ax.set_ylim([0, 1])\n",
    "    plt.grid(True)\n",
    "    fit_wls = sm.WLS(bin_correct_means, sm.add_constant(bin_prediction_means), weights=bin_counts).fit()\n",
    "    print(fit_wls.params)\n",
    "    y_regression = [fit_wls.params[0] + fit_wls.params[1]*x for x in bin_prediction_means]\n",
    "    plt.plot(bin_prediction_means, y_regression, label='Weighted Least Squares Regression', color=\"green\")\n",
    "    plt.plot(bin_prediction_means, bin_correct_means, label='Actual Calibration', color=\"#1f77b4\")\n",
    "    plt.plot((0, 1), (0, 1), label='Perfect Calibration', color=\"#ff7f0e\")\n",
    "    bin_count = brier['detail']['bin_count']\n",
    "    counts = np.array(bin_counts)\n",
    "    bins = (np.arange(bin_count) + 0.5) / bin_count\n",
    "    plt.legend(loc='upper center')\n",
    "    plt.xlabel('Predicted R')\n",
    "    plt.ylabel('Actual R')\n",
    "    plt.twinx()\n",
    "    plt.ylabel('Number of reviews')\n",
    "    plt.bar(bins, counts, width=(0.8 / bin_count), ec='k', lw=.2, alpha=0.5, label='Number of reviews')\n",
    "    plt.legend(loc='lower center')\n",
    "\n",
    "\n",
    "plot_brier(dataset['p'], dataset['y'], bins=40)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.ticker as ticker\n",
    "\n",
    "def to_percent(temp, position):\n",
    "    return '%1.0f' % (100 * temp) + '%'\n",
    "\n",
    "fig = plt.figure(1)\n",
    "ax1 = fig.add_subplot(111)\n",
    "ax2 = ax1.twinx()\n",
    "lns = []\n",
    "\n",
    "stability_calibration = pd.DataFrame(columns=['stability', 'predicted_retention', 'actual_retention'])\n",
    "stability_calibration = dataset[['stability', 'p', 'y']].copy()\n",
    "stability_calibration['bin'] = stability_calibration['stability'].map(lambda x: math.pow(1.2, math.floor(math.log(x, 1.2))))\n",
    "stability_group = stability_calibration.groupby('bin').count()\n",
    "\n",
    "lns1 = ax1.bar(x=stability_group.index, height=stability_group['y'], width=stability_group.index / 5.5,\n",
    "                ec='k', lw=.2, label='Number of predictions', alpha=0.5)\n",
    "ax1.set_ylabel(\"Number of predictions\")\n",
    "ax1.set_xlabel(\"Stability (days)\")\n",
    "ax1.semilogx()\n",
    "lns.append(lns1)\n",
    "\n",
    "stability_group = stability_calibration.groupby(by='bin').agg('mean')\n",
    "lns2 = ax2.plot(stability_group['y'], label='Actual retention')\n",
    "lns3 = ax2.plot(stability_group['p'], label='Predicted retention')\n",
    "ax2.set_ylabel(\"Retention\")\n",
    "ax2.set_ylim(0, 1)\n",
    "lns.append(lns2[0])\n",
    "lns.append(lns3[0])\n",
    "\n",
    "labs = [l.get_label() for l in lns]\n",
    "ax2.legend(lns, labs, loc='lower right')\n",
    "plt.grid(linestyle='--')\n",
    "plt.gca().yaxis.set_major_formatter(ticker.FuncFormatter(to_percent))\n",
    "plt.gca().xaxis.set_major_formatter(ticker.FormatStrFormatter('%d'))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style type=\"text/css\">\n",
       "#T_26a38_row0_col0, #T_26a38_row0_col1, #T_26a38_row0_col2, #T_26a38_row0_col4, #T_26a38_row0_col5, #T_26a38_row1_col0, #T_26a38_row1_col1, #T_26a38_row1_col2, #T_26a38_row1_col3, #T_26a38_row1_col4, #T_26a38_row2_col0, #T_26a38_row2_col1, #T_26a38_row2_col3, #T_26a38_row2_col4, #T_26a38_row3_col0, #T_26a38_row3_col1, #T_26a38_row3_col2, #T_26a38_row3_col3, #T_26a38_row4_col0, #T_26a38_row4_col1, #T_26a38_row4_col2, #T_26a38_row4_col3, #T_26a38_row4_col4, #T_26a38_row5_col0, #T_26a38_row5_col1, #T_26a38_row5_col2, #T_26a38_row5_col3, #T_26a38_row5_col4, #T_26a38_row6_col0, #T_26a38_row6_col1, #T_26a38_row6_col2, #T_26a38_row6_col3, #T_26a38_row7_col0, #T_26a38_row7_col1, #T_26a38_row7_col2, #T_26a38_row8_col0, #T_26a38_row8_col1, #T_26a38_row8_col3, #T_26a38_row9_col0, #T_26a38_row9_col1, #T_26a38_row9_col2, #T_26a38_row10_col0, #T_26a38_row10_col1, #T_26a38_row11_col0, #T_26a38_row11_col1, #T_26a38_row12_col0, #T_26a38_row12_col1, #T_26a38_row13_col0, #T_26a38_row13_col1, #T_26a38_row13_col4, #T_26a38_row14_col0, #T_26a38_row15_col0, #T_26a38_row15_col3, #T_26a38_row15_col4, #T_26a38_row16_col0, #T_26a38_row16_col3, #T_26a38_row16_col4, #T_26a38_row17_col0, #T_26a38_row17_col3, #T_26a38_row18_col3, #T_26a38_row18_col4, #T_26a38_row19_col2, #T_26a38_row19_col3, #T_26a38_row19_col4 {\n",
       "  background-color: #000000;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_26a38_row0_col3 {\n",
       "  background-color: #ffbdbd;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row1_col5, #T_26a38_row10_col3, #T_26a38_row15_col1 {\n",
       "  background-color: #c9c9ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row2_col2, #T_26a38_row14_col1 {\n",
       "  background-color: #cdcdff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row2_col5 {\n",
       "  background-color: #ffb5b5;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row3_col4 {\n",
       "  background-color: #f5f5ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row3_col5 {\n",
       "  background-color: #ff4141;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_26a38_row4_col5 {\n",
       "  background-color: #fff5f5;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row5_col5, #T_26a38_row8_col5, #T_26a38_row14_col5 {\n",
       "  background-color: #d1d1ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row6_col4 {\n",
       "  background-color: #ffd1d1;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row6_col5, #T_26a38_row8_col4 {\n",
       "  background-color: #fff1f1;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row7_col3 {\n",
       "  background-color: #ffe1e1;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row7_col4 {\n",
       "  background-color: #e5e5ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row7_col5, #T_26a38_row9_col3, #T_26a38_row14_col3 {\n",
       "  background-color: #ddddff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row8_col2, #T_26a38_row13_col2 {\n",
       "  background-color: #7171ff;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_26a38_row9_col4 {\n",
       "  background-color: #ffdddd;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row9_col5, #T_26a38_row16_col5 {\n",
       "  background-color: #ededff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row10_col2 {\n",
       "  background-color: #c1c1ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row10_col4 {\n",
       "  background-color: #ff8585;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_26a38_row10_col5, #T_26a38_row17_col4 {\n",
       "  background-color: #ff9999;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row11_col2 {\n",
       "  background-color: #9d9dff;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_26a38_row11_col3, #T_26a38_row18_col5, #T_26a38_row19_col5 {\n",
       "  background-color: #bdbdff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row11_col4 {\n",
       "  background-color: #ff4d4d;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_26a38_row11_col5 {\n",
       "  background-color: #ffa5a5;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row12_col2 {\n",
       "  background-color: #7575ff;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_26a38_row12_col3 {\n",
       "  background-color: #ff7979;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_26a38_row12_col4, #T_26a38_row16_col2 {\n",
       "  background-color: #ff9191;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row12_col5 {\n",
       "  background-color: #ffc9c9;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row13_col3 {\n",
       "  background-color: #ff8989;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row13_col5 {\n",
       "  background-color: #ff6565;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_26a38_row14_col2 {\n",
       "  background-color: #a5a5ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row14_col4 {\n",
       "  background-color: #ff2525;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_26a38_row15_col2 {\n",
       "  background-color: #ff6969;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_26a38_row15_col5 {\n",
       "  background-color: #ffe9e9;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row16_col1, #T_26a38_row18_col2 {\n",
       "  background-color: #d5d5ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row17_col1, #T_26a38_row18_col0 {\n",
       "  background-color: #6969ff;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_26a38_row17_col2 {\n",
       "  background-color: #ffcdcd;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row17_col5 {\n",
       "  background-color: #e1e1ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row18_col1 {\n",
       "  background-color: #b1b1ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_26a38_row19_col0 {\n",
       "  background-color: #3535ff;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_26a38_row19_col1 {\n",
       "  background-color: #8181ff;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "</style>\n",
       "<table id=\"T_26a38\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th class=\"index_name level0\" >d_bin</th>\n",
       "      <th id=\"T_26a38_level0_col0\" class=\"col_heading level0 col0\" >2</th>\n",
       "      <th id=\"T_26a38_level0_col1\" class=\"col_heading level0 col1\" >3</th>\n",
       "      <th id=\"T_26a38_level0_col2\" class=\"col_heading level0 col2\" >5</th>\n",
       "      <th id=\"T_26a38_level0_col3\" class=\"col_heading level0 col3\" >6</th>\n",
       "      <th id=\"T_26a38_level0_col4\" class=\"col_heading level0 col4\" >8</th>\n",
       "      <th id=\"T_26a38_level0_col5\" class=\"col_heading level0 col5\" >10</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th class=\"index_name level0\" >s_bin</th>\n",
       "      <th class=\"blank col0\" >&nbsp;</th>\n",
       "      <th class=\"blank col1\" >&nbsp;</th>\n",
       "      <th class=\"blank col2\" >&nbsp;</th>\n",
       "      <th class=\"blank col3\" >&nbsp;</th>\n",
       "      <th class=\"blank col4\" >&nbsp;</th>\n",
       "      <th class=\"blank col5\" >&nbsp;</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th id=\"T_26a38_level0_row0\" class=\"row_heading level0 row0\" >0.190000</th>\n",
       "      <td id=\"T_26a38_row0_col0\" class=\"data row0 col0\" ></td>\n",
       "      <td id=\"T_26a38_row0_col1\" class=\"data row0 col1\" ></td>\n",
       "      <td id=\"T_26a38_row0_col2\" class=\"data row0 col2\" ></td>\n",
       "      <td id=\"T_26a38_row0_col3\" class=\"data row0 col3\" >2.62%</td>\n",
       "      <td id=\"T_26a38_row0_col4\" class=\"data row0 col4\" ></td>\n",
       "      <td id=\"T_26a38_row0_col5\" class=\"data row0 col5\" ></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_26a38_level0_row1\" class=\"row_heading level0 row1\" >0.360000</th>\n",
       "      <td id=\"T_26a38_row1_col0\" class=\"data row1 col0\" ></td>\n",
       "      <td id=\"T_26a38_row1_col1\" class=\"data row1 col1\" ></td>\n",
       "      <td id=\"T_26a38_row1_col2\" class=\"data row1 col2\" ></td>\n",
       "      <td id=\"T_26a38_row1_col3\" class=\"data row1 col3\" ></td>\n",
       "      <td id=\"T_26a38_row1_col4\" class=\"data row1 col4\" ></td>\n",
       "      <td id=\"T_26a38_row1_col5\" class=\"data row1 col5\" >-2.12%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_26a38_level0_row2\" class=\"row_heading level0 row2\" >0.510000</th>\n",
       "      <td id=\"T_26a38_row2_col0\" class=\"data row2 col0\" ></td>\n",
       "      <td id=\"T_26a38_row2_col1\" class=\"data row2 col1\" ></td>\n",
       "      <td id=\"T_26a38_row2_col2\" class=\"data row2 col2\" >-1.89%</td>\n",
       "      <td id=\"T_26a38_row2_col3\" class=\"data row2 col3\" ></td>\n",
       "      <td id=\"T_26a38_row2_col4\" class=\"data row2 col4\" ></td>\n",
       "      <td id=\"T_26a38_row2_col5\" class=\"data row2 col5\" >2.90%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_26a38_level0_row3\" class=\"row_heading level0 row3\" >0.710000</th>\n",
       "      <td id=\"T_26a38_row3_col0\" class=\"data row3 col0\" ></td>\n",
       "      <td id=\"T_26a38_row3_col1\" class=\"data row3 col1\" ></td>\n",
       "      <td id=\"T_26a38_row3_col2\" class=\"data row3 col2\" ></td>\n",
       "      <td id=\"T_26a38_row3_col3\" class=\"data row3 col3\" ></td>\n",
       "      <td id=\"T_26a38_row3_col4\" class=\"data row3 col4\" >-0.33%</td>\n",
       "      <td id=\"T_26a38_row3_col5\" class=\"data row3 col5\" >7.44%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_26a38_level0_row4\" class=\"row_heading level0 row4\" >1.000000</th>\n",
       "      <td id=\"T_26a38_row4_col0\" class=\"data row4 col0\" ></td>\n",
       "      <td id=\"T_26a38_row4_col1\" class=\"data row4 col1\" ></td>\n",
       "      <td id=\"T_26a38_row4_col2\" class=\"data row4 col2\" ></td>\n",
       "      <td id=\"T_26a38_row4_col3\" class=\"data row4 col3\" ></td>\n",
       "      <td id=\"T_26a38_row4_col4\" class=\"data row4 col4\" ></td>\n",
       "      <td id=\"T_26a38_row4_col5\" class=\"data row4 col5\" >0.45%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_26a38_level0_row5\" class=\"row_heading level0 row5\" >1.400000</th>\n",
       "      <td id=\"T_26a38_row5_col0\" class=\"data row5 col0\" ></td>\n",
       "      <td id=\"T_26a38_row5_col1\" class=\"data row5 col1\" ></td>\n",
       "      <td id=\"T_26a38_row5_col2\" class=\"data row5 col2\" ></td>\n",
       "      <td id=\"T_26a38_row5_col3\" class=\"data row5 col3\" ></td>\n",
       "      <td id=\"T_26a38_row5_col4\" class=\"data row5 col4\" ></td>\n",
       "      <td id=\"T_26a38_row5_col5\" class=\"data row5 col5\" >-1.82%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_26a38_level0_row6\" class=\"row_heading level0 row6\" >1.960000</th>\n",
       "      <td id=\"T_26a38_row6_col0\" class=\"data row6 col0\" ></td>\n",
       "      <td id=\"T_26a38_row6_col1\" class=\"data row6 col1\" ></td>\n",
       "      <td id=\"T_26a38_row6_col2\" class=\"data row6 col2\" ></td>\n",
       "      <td id=\"T_26a38_row6_col3\" class=\"data row6 col3\" ></td>\n",
       "      <td id=\"T_26a38_row6_col4\" class=\"data row6 col4\" >1.87%</td>\n",
       "      <td id=\"T_26a38_row6_col5\" class=\"data row6 col5\" >0.54%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_26a38_level0_row7\" class=\"row_heading level0 row7\" >2.740000</th>\n",
       "      <td id=\"T_26a38_row7_col0\" class=\"data row7 col0\" ></td>\n",
       "      <td id=\"T_26a38_row7_col1\" class=\"data row7 col1\" ></td>\n",
       "      <td id=\"T_26a38_row7_col2\" class=\"data row7 col2\" ></td>\n",
       "      <td id=\"T_26a38_row7_col3\" class=\"data row7 col3\" >1.10%</td>\n",
       "      <td id=\"T_26a38_row7_col4\" class=\"data row7 col4\" >-1.04%</td>\n",
       "      <td id=\"T_26a38_row7_col5\" class=\"data row7 col5\" >-1.26%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_26a38_level0_row8\" class=\"row_heading level0 row8\" >3.840000</th>\n",
       "      <td id=\"T_26a38_row8_col0\" class=\"data row8 col0\" ></td>\n",
       "      <td id=\"T_26a38_row8_col1\" class=\"data row8 col1\" ></td>\n",
       "      <td id=\"T_26a38_row8_col2\" class=\"data row8 col2\" >-5.52%</td>\n",
       "      <td id=\"T_26a38_row8_col3\" class=\"data row8 col3\" ></td>\n",
       "      <td id=\"T_26a38_row8_col4\" class=\"data row8 col4\" >0.53%</td>\n",
       "      <td id=\"T_26a38_row8_col5\" class=\"data row8 col5\" >-1.77%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_26a38_level0_row9\" class=\"row_heading level0 row9\" >5.380000</th>\n",
       "      <td id=\"T_26a38_row9_col0\" class=\"data row9 col0\" ></td>\n",
       "      <td id=\"T_26a38_row9_col1\" class=\"data row9 col1\" ></td>\n",
       "      <td id=\"T_26a38_row9_col2\" class=\"data row9 col2\" ></td>\n",
       "      <td id=\"T_26a38_row9_col3\" class=\"data row9 col3\" >-1.34%</td>\n",
       "      <td id=\"T_26a38_row9_col4\" class=\"data row9 col4\" >1.33%</td>\n",
       "      <td id=\"T_26a38_row9_col5\" class=\"data row9 col5\" >-0.63%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_26a38_level0_row10\" class=\"row_heading level0 row10\" >7.530000</th>\n",
       "      <td id=\"T_26a38_row10_col0\" class=\"data row10 col0\" ></td>\n",
       "      <td id=\"T_26a38_row10_col1\" class=\"data row10 col1\" ></td>\n",
       "      <td id=\"T_26a38_row10_col2\" class=\"data row10 col2\" >-2.39%</td>\n",
       "      <td id=\"T_26a38_row10_col3\" class=\"data row10 col3\" >-2.15%</td>\n",
       "      <td id=\"T_26a38_row10_col4\" class=\"data row10 col4\" >4.78%</td>\n",
       "      <td id=\"T_26a38_row10_col5\" class=\"data row10 col5\" >4.06%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_26a38_level0_row11\" class=\"row_heading level0 row11\" >10.540000</th>\n",
       "      <td id=\"T_26a38_row11_col0\" class=\"data row11 col0\" ></td>\n",
       "      <td id=\"T_26a38_row11_col1\" class=\"data row11 col1\" ></td>\n",
       "      <td id=\"T_26a38_row11_col2\" class=\"data row11 col2\" >-3.78%</td>\n",
       "      <td id=\"T_26a38_row11_col3\" class=\"data row11 col3\" >-2.64%</td>\n",
       "      <td id=\"T_26a38_row11_col4\" class=\"data row11 col4\" >6.92%</td>\n",
       "      <td id=\"T_26a38_row11_col5\" class=\"data row11 col5\" >3.56%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_26a38_level0_row12\" class=\"row_heading level0 row12\" >14.760000</th>\n",
       "      <td id=\"T_26a38_row12_col0\" class=\"data row12 col0\" ></td>\n",
       "      <td id=\"T_26a38_row12_col1\" class=\"data row12 col1\" ></td>\n",
       "      <td id=\"T_26a38_row12_col2\" class=\"data row12 col2\" >-5.42%</td>\n",
       "      <td id=\"T_26a38_row12_col3\" class=\"data row12 col3\" >5.26%</td>\n",
       "      <td id=\"T_26a38_row12_col4\" class=\"data row12 col4\" >4.28%</td>\n",
       "      <td id=\"T_26a38_row12_col5\" class=\"data row12 col5\" >2.13%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_26a38_level0_row13\" class=\"row_heading level0 row13\" >20.660000</th>\n",
       "      <td id=\"T_26a38_row13_col0\" class=\"data row13 col0\" ></td>\n",
       "      <td id=\"T_26a38_row13_col1\" class=\"data row13 col1\" ></td>\n",
       "      <td id=\"T_26a38_row13_col2\" class=\"data row13 col2\" >-5.54%</td>\n",
       "      <td id=\"T_26a38_row13_col3\" class=\"data row13 col3\" >4.62%</td>\n",
       "      <td id=\"T_26a38_row13_col4\" class=\"data row13 col4\" ></td>\n",
       "      <td id=\"T_26a38_row13_col5\" class=\"data row13 col5\" >5.98%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_26a38_level0_row14\" class=\"row_heading level0 row14\" >28.930000</th>\n",
       "      <td id=\"T_26a38_row14_col0\" class=\"data row14 col0\" ></td>\n",
       "      <td id=\"T_26a38_row14_col1\" class=\"data row14 col1\" >-1.92%</td>\n",
       "      <td id=\"T_26a38_row14_col2\" class=\"data row14 col2\" >-3.56%</td>\n",
       "      <td id=\"T_26a38_row14_col3\" class=\"data row14 col3\" >-1.40%</td>\n",
       "      <td id=\"T_26a38_row14_col4\" class=\"data row14 col4\" >8.51%</td>\n",
       "      <td id=\"T_26a38_row14_col5\" class=\"data row14 col5\" >-1.80%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_26a38_level0_row15\" class=\"row_heading level0 row15\" >40.500000</th>\n",
       "      <td id=\"T_26a38_row15_col0\" class=\"data row15 col0\" ></td>\n",
       "      <td id=\"T_26a38_row15_col1\" class=\"data row15 col1\" >-2.14%</td>\n",
       "      <td id=\"T_26a38_row15_col2\" class=\"data row15 col2\" >5.81%</td>\n",
       "      <td id=\"T_26a38_row15_col3\" class=\"data row15 col3\" ></td>\n",
       "      <td id=\"T_26a38_row15_col4\" class=\"data row15 col4\" ></td>\n",
       "      <td id=\"T_26a38_row15_col5\" class=\"data row15 col5\" >0.84%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_26a38_level0_row16\" class=\"row_heading level0 row16\" >56.690000</th>\n",
       "      <td id=\"T_26a38_row16_col0\" class=\"data row16 col0\" ></td>\n",
       "      <td id=\"T_26a38_row16_col1\" class=\"data row16 col1\" >-1.68%</td>\n",
       "      <td id=\"T_26a38_row16_col2\" class=\"data row16 col2\" >4.26%</td>\n",
       "      <td id=\"T_26a38_row16_col3\" class=\"data row16 col3\" ></td>\n",
       "      <td id=\"T_26a38_row16_col4\" class=\"data row16 col4\" ></td>\n",
       "      <td id=\"T_26a38_row16_col5\" class=\"data row16 col5\" >-0.72%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_26a38_level0_row17\" class=\"row_heading level0 row17\" >79.370000</th>\n",
       "      <td id=\"T_26a38_row17_col0\" class=\"data row17 col0\" ></td>\n",
       "      <td id=\"T_26a38_row17_col1\" class=\"data row17 col1\" >-5.79%</td>\n",
       "      <td id=\"T_26a38_row17_col2\" class=\"data row17 col2\" >1.90%</td>\n",
       "      <td id=\"T_26a38_row17_col3\" class=\"data row17 col3\" ></td>\n",
       "      <td id=\"T_26a38_row17_col4\" class=\"data row17 col4\" >3.94%</td>\n",
       "      <td id=\"T_26a38_row17_col5\" class=\"data row17 col5\" >-1.25%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_26a38_level0_row18\" class=\"row_heading level0 row18\" >111.120000</th>\n",
       "      <td id=\"T_26a38_row18_col0\" class=\"data row18 col0\" >-5.89%</td>\n",
       "      <td id=\"T_26a38_row18_col1\" class=\"data row18 col1\" >-2.99%</td>\n",
       "      <td id=\"T_26a38_row18_col2\" class=\"data row18 col2\" >-1.69%</td>\n",
       "      <td id=\"T_26a38_row18_col3\" class=\"data row18 col3\" ></td>\n",
       "      <td id=\"T_26a38_row18_col4\" class=\"data row18 col4\" ></td>\n",
       "      <td id=\"T_26a38_row18_col5\" class=\"data row18 col5\" >-2.61%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_26a38_level0_row19\" class=\"row_heading level0 row19\" >155.570000</th>\n",
       "      <td id=\"T_26a38_row19_col0\" class=\"data row19 col0\" >-7.90%</td>\n",
       "      <td id=\"T_26a38_row19_col1\" class=\"data row19 col1\" >-4.95%</td>\n",
       "      <td id=\"T_26a38_row19_col2\" class=\"data row19 col2\" ></td>\n",
       "      <td id=\"T_26a38_row19_col3\" class=\"data row19 col3\" ></td>\n",
       "      <td id=\"T_26a38_row19_col4\" class=\"data row19 col4\" ></td>\n",
       "      <td id=\"T_26a38_row19_col5\" class=\"data row19 col5\" >-2.50%</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x2bfe29fd0>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B_W_Metric_raw = dataset[['difficulty', 'stability', 'p', 'y']].copy()\n",
    "B_W_Metric_raw['s_bin'] = B_W_Metric_raw['stability'].map(lambda x: round(math.pow(1.4, math.floor(math.log(x, 1.4))), 2))\n",
    "B_W_Metric_raw['d_bin'] = B_W_Metric_raw['difficulty'].map(lambda x: int(round(x)))\n",
    "B_W_Metric = B_W_Metric_raw.groupby(by=['s_bin', 'd_bin']).agg('mean').reset_index()\n",
    "B_W_Metric_count = B_W_Metric_raw.groupby(by=['s_bin', 'd_bin']).agg('count').reset_index()\n",
    "B_W_Metric['B-W'] = B_W_Metric['p'] - B_W_Metric['y']\n",
    "n = len(dataset)\n",
    "bins = len(B_W_Metric)\n",
    "B_W_Metric_pivot = B_W_Metric[B_W_Metric_count['p'] > max(50, n / (3 * bins))].pivot(index=\"s_bin\", columns='d_bin', values='B-W')\n",
    "B_W_Metric_pivot.apply(pd.to_numeric).style.background_gradient(cmap='seismic', axis=None, vmin=-0.2, vmax=0.2).format(\"{:.2%}\", na_rep='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot: xlabel='d_bin'>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "B_W_Metric_raw.groupby(by=['d_bin']).agg('count').reset_index().plot.bar(x='d_bin', y='p', legend=False)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "fsrs4anki",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
